Blogs perficient / blogs / perficient / Python Optimisation: Améliorer les performances du code

Introduction

Python est un langage de programmation incroyablement puissant et facile à utiliser. Cependant, il peut être lent sinon optimisé correctement! Ce guide vous apprendra comment turbuler votre code, le rendant plus rapide, plus maigre et plus efficace. Bouclez-vous et plongeons dans certains hacks d’optimisation épique!

Pour en savoir plus sur les bases de Python, consultez notre guide pour le débutant de la programmation Python.

1. Choisir les bonnes structures de données pour de meilleures performances

Choisir la bonne structure de données, c’est comme choisir le bon outil pour un travail – faites-le mal et vous frapperez un clou avec un tournevis!

1.1 listes vs tuples: Optimisez votre stockage de données

• Utilisez des tuples au lieu des listes Lorsque les éléments ne changent pas (données immuables). Les tuples ont des frais généraux plus bas et sont rapides!

# List (mutable)
my_list = [1, 2, 3]
# Tuple (immutable, faster)
my_tuple = (1, 2, 3)

1.2 Utiliser des ensembles et des dictionnaires pour des recherches rapides

• Recherche dans une liste c’est comme chercher une chaussette perdue dans une pièce en désordre . D’autre part, Recherche dans un ensemble ou un dictionnaire c’est comme googler quelque chose!

# Slow list lookup (O(n))
numbers = [1, 2, 3, 4, 5]
print(3 in numbers)  # Yawn... Slow!

# Fast set lookup (O(1))
numbers_set = {1, 2, 3, 4, 5}
print(3 in numbers_set)  # Blink and you'll miss it! 

1.3 Utilisez des générateurs au lieu de listes pour l’efficacité de la mémoire

• Pourquoi stocker des millions de valeurs en mémoire alors que vous pouvez les générer à la volée?

# Generator (better memory usage)
def squared_numbers(n):
    for i in range(n):
        yield i * i
squares = squared_numbers(1000000)  # No memory explosion! 

2. Optimisations de boucle pour le code Python plus rapide

2.1 Évitez le calcul répété dans les boucles pour améliorer les performances

# Inefficient
for i in range(10000):
    result = expensive_function()  # Ugh! Repeating this is a performance killer 
    process(result)

# Optimized
cached_result = expensive_function()  # Call it once and chill 
for i in range(10000):
    process(cached_result)

2.2 Utilisez des compréhensions de la liste au lieu de boucles traditionnelles pour le code pythonique

• Pourquoi écrire des boucles ennuyeuses alors que vous pouvez être pythonique?

# Traditional loop (meh...)
squares = []
for i in range(10):
    squares.append(i * i)

# Optimized list comprehension (so sleek! )
squares = [i * i for i in range(10)]

3. Techniques d’optimisation des chaînes

3.1 Utilisez join () au lieu de la concaténation des cordes pour de meilleures performances

# Inefficient (Creates too many temporary strings )
words = ["Hello", "world", "Python"]
sentence = ""
for word in words:
    sentence += word + " "

# Optimized (Effortless and FAST )
sentence = " ".join(words)

3.2 Utilisez des cordes F pour la mise en forme des chaînes dans Python (Python 3.6+)

name = "Alice"
age = 25

# Old formatting (Ew )
print("My name is {} and I am {} years old.".format(name, age))

# Optimized f-string (Sleek & stylish )
print(f"My name is {name} and I am {age} years old.")

4.1 Utilisez du temps pour mesurer le temps d’exécution

import timeit
print(timeit.timeit("sum(range(1000))", number=10000))  # How fast is your code? 

4.2 Utiliser le CPROFILE pour un profilage de performances détaillé

import cProfile
cProfile.run('my_function()')  # Find bottlenecks like a pro! 

Pour en savoir plus sur le profilage, consultez notre guide des outils de profilage Python.

5. Techniques d’optimisation de la mémoire

5.1 Utiliser sys.getSizeOf () pour vérifier l’utilisation de la mémoire

import sys
my_list = [1, 2, 3, 4, 5]
print(sys.getsizeof(my_list))  # How big is that object? 

5.2 Utilisez Del et GC.Collect () pour gérer la mémoire

import gc
large_object = [i for i in range(1000000)]
del large_object  # Say bye-bye to memory hog! 
gc.collect()  # Cleanup crew 

6. Traitement parallèle et multithreading

6.1 Utiliser le multiprocessement pour les tâches liées au CPU

from multiprocessing import Pool

def square(n):
    return n * n

with Pool(4) as p:  # Use 4 CPU cores 
    results = p.map(square, range(100))

6.2 Utiliser le filetage pour les tâches liées aux E / S

import threading

def print_numbers():
    for i in range(10):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

Pour en savoir plus sur le traitement parallèle, consultez notre introduction à Python Multithreading.

Conclusion

Félicitations! Vous avez débloqué le plein potentiel de Python en apprenant ces astuces d’optimisation des tueurs. Allez maintenant et écrivez un code Python en fast-fast, économe en mémoire et propre.

Vous avez des hacks d’optimisation préférés? Déposez-les dans les commentaires!

Pour des informations plus détaillées sur l’optimisation de Python, consultez ces ressources: